#include <iostream>
#include <vector>
#include <string>
#include <cstdint>
#include <cassert>
#include <cstring>
#include <ctime>
#include <cstdio>
#include <unordered_map>
#include <functional>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>

/*
    time() 获得时间戳
    将时间戳转化为本地时间的 struct tm 结构体中 (它已经为我们划分好了不同时间字段)
    strftime()  格式化字符串,从ltm结构中取出信息,以指定时间格式,转化为字符串,存入进tmp中
    技巧：加上do while循环能应用于代码的各种情况
    宏里面不能有换行，所以加上\转义换行，代表后面没有换行
    使用不定参的...只能声明定义的时候用，使用的时候用__VA_ARGS__    加上##,因为可能没有参数传进
*/
#define INF 0
#define DBG 1
#define ERR 2
#define DEFAULT_LEVEL INF

#define LOG(level, format, ...)                                                                   \
    do                                                                                            \
    {                                                                                             \
        if (level >= DEFAULT_LEVEL)                                                               \
        {                                                                                         \
            time_t t = time(NULL);                                                                \
            struct tm *ltm = localtime(&t);                                                       \
            char tmp[32] = {0};                                                                   \
            strftime(tmp, 31, "%Y-%m-%d %H:%M:%S", ltm);                                          \
            fprintf(stdout, "[%s] [%s:%d] " format "\n", tmp, __FILE__, __LINE__, ##__VA_ARGS__); \
        }                                                                                         \
    } while (0)
#define ILOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DLOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ELOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)

#define BUFFER_DEFAULT_SIZE 1024
class Buffer
{
private:
    std::vector<char> _buffer; // 使用vector进行内存空间管理
    uint64_t _reader_idx;      // 读偏移
    uint64_t _writer_idx;      // 写偏移
public:
    Buffer()
        : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    char *Begin() { return &(*_buffer.begin()); } //_buffer.begin()返回迭代器,解引用取出数据,再取它的地址
    // 获取当前写入起始地址, _buffer的空间起始地址，加上写偏移量
    char *WritePosition()
    {
        return Begin() + _writer_idx;
    }
    // 获取当前读取起始地址
    char *ReadPosition()
    {
        return Begin() + _reader_idx;
    }
    // 获取缓冲区末尾空闲空间大小--写偏移之后的空闲空间, 总体空间大小减去写偏移
    uint64_t TailIdleSize()
    {
        return _buffer.size() - _writer_idx;
    }
    // 获取缓冲区起始空闲空间大小--读偏移之前的空闲空间
    uint64_t HeadIdleSize()
    {
        return _reader_idx;
    }
    // 获取可读数据大小 = 写偏移 - 读偏移
    uint64_t ReadAbleSize()
    {
        return _writer_idx - _reader_idx;
    }
    // 将读偏移向后移动
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)
            return;
        // 向后移动的大小,必须小于等于可读数据的大小
        assert(len <= ReadAbleSize());
        _reader_idx += len;
    }
    // 将写偏移向后移动
    void MoveWriteOffset(uint64_t len)
    {
        // 向后移动的大小,必须小于等于后面空闲空间的大小
        assert(len <= TailIdleSize());
        _writer_idx += len;
    }
    // 确保可写空间足够（整体空闲空间够了就移动数据，否则就扩容）
    void EnsureWriteSpace(uint64_t len)
    {
        // 如果末尾空间大小足够,直接返回
        if (len <= TailIdleSize())
            return;
        // 末尾空间大小不够,再加上起始空间大小是否足够,如果足够,将数据整体移动到起始位置
        if (len <= HeadIdleSize() + TailIdleSize())
        {
            // 移动到起始位置
            uint64_t rsz = ReadAbleSize(); // 把当前数据保存起来
            std::copy(ReadPosition(), WritePosition(), Begin());
            _reader_idx = 0;
            _writer_idx = rsz;
        }
        else // 总体空间大小不够,需要扩容,不移动数据,直接给写偏移量之后扩充足够的空间
        {
            _buffer.resize(_writer_idx + len);
        }
    }
    // 写入数据(任意类型)
    void Write(const void *data, uint64_t len)
    {
        // 1.先保证有足够的空间 2.再将数据写入缓冲区
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        const char *d = (const char *)data;
        std::copy(d, d + len, WritePosition());
    }
    // 写入数据(字符串类型)
    void WriteString(const std::string &data)
    {
        Write(data.c_str(), data.size());
    }
    // 写入数据(自定义Buffer类型)
    void WriteBuffer(Buffer &data)
    {
        Write(data.ReadPosition(), data.ReadAbleSize());
    }
    // 写入数据后,将更新写入位置
    void WriteAndPush(const void *data, uint64_t len)
    {

        Write(data, len);
        MoveWriteOffset(len);
    }
    void WriteStringAndPush(const std::string &data)
    {
        WriteString(data);
        MoveWriteOffset(data.size());
    }
    void WriteBufferAndPush(Buffer &data)
    {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadAbleSize());
    }
    // 读取数据
    void Read(void *buf, uint64_t len)
    {
        // 要求要获取的数据大小必须小于可读数据大小
        assert(len <= ReadAbleSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
    }
    std::string ReadAsString(uint64_t len)
    {
        assert(len <= ReadAbleSize());

        std::string str;
        str.resize(len);
        Read(&str[0], str.size());
        return str;
    }
    // 读取数据,将更新读入位置
    void ReadAndPop(void *buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }
    std::string ReadAsStringAndPop(uint64_t len)
    {
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }
    // CR LF: 回车  换行
    char *FindCRLF()
    {
        // 返回 '\n' 所在下标
        char *pos = (char *)memchr(ReadPosition(), '\n', ReadAbleSize());
        return pos;
    }
    std::string GetLine()
    {
        char *pos = FindCRLF();
        if (pos == NULL)
        {
            return "";
        }
        // 加 1 的目是取出 '\n' 字符
        return ReadAsString(pos - ReadPosition() + 1);
    }
    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }
    // 清空缓冲区
    void Clear()
    {
        // 只需要将偏移量归0即可
        _reader_idx = 0;
        _writer_idx = 0;
    }
};

#define MAX_LISTEN 1024 // 可监听最大连接数
class Socket
{
private:
    int _sockfd;

public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() { Close(); }
    int Fd() { return _sockfd; }
    // 创建套接字
    bool Create()
    {
        // int socket(int domain, int type, int protocol);
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            ELOG("CREATE SOCKET FAILED!");
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // int bind(int sockfd, struct sockaddr *addr, socklen_t len);
        int ret = bind(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ELOG("BIND ADDRESS FAILED!");
            return false;
        }
        return true;
    }
    // 开始监听
    bool Listen(int backlog = MAX_LISTEN)
    {
        // int listen(int sockfd, int backlog);
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            ELOG("SOCKET LISTEN FAILED!");
            return false;
        }
        return true;
    }
    // 向服务器发起连接(客户端)
    bool Connect(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        // int connect(int sockfd, struct sockaddr *addr, socklen_t len);
        int ret = connect(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            ELOG("CONNECT SERVER FAILED!");
            return false;
        }
        return true;
    }
    // 获取新连接
    int Accept()
    {
        // int accept(int sockfd, struct sockaddr *addr, socklen_t len);
        int newfd = accept(_sockfd, NULL, NULL);
        if (newfd < 0)
        {
            ELOG("SOCKET ACCEPT FAILED!");
            return -1;
        }
        return newfd;
    }
    // 接受数据
    ssize_t Recv(void *buffer, size_t len, int flag = 0) // ssize_t:有符号整形// flag = 0,默认阻塞,1非阻塞
    {
        // ssize_t ret = recv(int sockfd, void *buf,  size_t len, int flag);
        ssize_t ret = recv(_sockfd, buffer, len, flag); //????
        if (ret <= 0)
        {
            // EAGAIN :表示当前socket的接受缓冲区中没有数据了,在 非阻塞 的情况下才会有这个错误
            // EINTR  :表示当前socket的阻塞等待,被信号打断了
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0; // 表示这次没有接受到数据
            }
            ELOG("SOCKET RECV FAILED!");
            return -1;
        }
        return ret; // 实际读取的数据长度
    }
    // 非阻塞读取
    ssize_t NonBlockRecv(void *buffer, size_t len)
    {
        return Recv(buffer, len, MSG_DONTROUTE); // MSG_DONTWAIT:表示当前接受为非阻塞
    }
    // 发送数据
    ssize_t Send(const void *buffer, size_t len, int flag = 0)
    {
        // ssize_t send(int sockfd, void *buff, size_t len, int flag);
        ssize_t ret = send(_sockfd, buffer, len, flag);
        if (ret < 0)
        {
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0;
            }
            ELOG("SOCKET SEND FAILED!");
            return -1;
        }
        return ret; // 实际发送的数据
    }
    // 非阻塞发送数据
    ssize_t NonBlockSend(void *buffer, size_t len)
    {
        return Send(buffer, len, MSG_DONTROUTE);
    }
    // 关闭套接字
    void Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }
    // 创建一个服务器连接(对于服务端监听连接整合)
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false)
    {
        // 1.创建套接字
        if (Create() == false)
            return false;
        // 4.设置非阻塞
        if (block_flag)
            NonBlock();
        // 2.绑定地址
        if (Bind(ip, port) == false)
            return false;
        // 3.开启监听
        if (Listen() == false)
            return false;
        // 5.启动地址重用
        ReuseAddress();
        return true;
    }
    // 创建一个客户端连接(客户端发起连接整合)
    bool CreateClient(uint16_t port, const std::string &ip)
    {
        // 1.创建套接字
        if (Create() == false)
            return false;
        // 2.指向连接服务器
        if (Connect(ip, port) == false)
            return false;
        return true;
    }
    // 设置套接字选项 -- 开启 地址 与 端口 复用
    void ReuseAddress()
    {
        /*
        参数2: level:选项的协议层（如 SOL_SOCKET、IPPROTO_TCP）
               level_1 = SOL_SOCKET（通用套接字选项)
               level_2 = IPPROTO_TCP（TCP协议选项）
        参数3: optname:选项名
               level_1 : SO_REUSEADDR, // 允许重用本地地址（避免 bind() 报 Address already in use）
                         SO_REUSEPORT  // 允许多个套接字绑定相同 IP+端口
                         ...
        参数4:  (大部分类型:int) val : 0/1 (不启动 或 启动)
        int setsockopt(int fd, int level, int optname, void *val, int vallen);
        */
        int val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(val));
        val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(val));
    }
    // 设置套接字阻塞属性 -- 设置为非阻塞
    void NonBlock()
    {
        /*
        // 介绍: fcntl (File Control)是一个 多功能文件描述符控制函数，用于修改已打开文件（或套接字）的属性。在网络编程中，它常用于设置套接字的 非阻塞模式
        // 参数2: cmd  控制命令（如 F_GETFL、F_SETFL、F_SETOWN 等）
        // 参数3: ...  可变参数（取决于 cmd，可能是整数、指针或结构体）
        //  int fcntl(int fd, int cmd, ...  / arg / );
        // F_GETFL: 获取当前文件状态标志
        // F_SETFL:设置新的文件状态标志（如设置为非阻塞模式）
        */
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }
};

class Poller;
class Channel
{
private:
    int _fd;
    Poller *_poller;
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    /*
        只有我们的连接(上层)才知道，一旦事件触发了该去怎么处理，所以需要设置回调函数。
        当启动读事件监控，就需要将channel挂到EventLoop上面进行事件监控，
        当可读事件触发，就会调用channel里设置的回调函数。
    */
    EventCallback _read_callback;  // 可读事件被触发的回调函数
    EventCallback _write_callback; // 可写事件被触发的回调函数
    EventCallback _error_callback; // 错误事件被触发的回调函数
    EventCallback _close_callback; // 连接断开事件被触发的回调函数
    EventCallback _event_callback; // 任意事件被触发的回调函数

public:
    Channel(Poller *poller, int fd)
        : _fd(fd), _poller(poller), _events(0), _revents(0) {}
    int Fd() { return _fd; }
    // 获取想要的监控事件
    uint32_t Events() { return _events; }
    // 设置实际就绪的事件
    void SetREvent(uint32_t events) { _revents = events; }
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }
    // 当前是否可读
    bool ReadAble() { return (_events & EPOLLIN); }
    // 当前是否可写
    bool WriteAble() { return (_events & EPOLLOUT); }
    // 启动读事件监控
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update();
    }
    // 启动写事件监控
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }
    // 关闭读事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update();
    }
    // 关闭写事件监控
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }
    // 关闭所有事件监控
    void DisableAll()
    {
        _events &= 0;
        Update();
    }
    /*
        关闭事件监控，只是不去关心这个事件了，但还是在EventLoop中。
        移除事件监控，才是真正的将它从EventLoop中移除
    */
    // 移除监控事件
    void Remove();
    // 添加或者修改监控事件
    void Update();
    /*
        EventLoop不用管你具体触发了什么事件我就去调用对应的回调函数，EventLoop不用管。
        EventLoop只管你触发了事件，我就调用你的HandleEvent，你自己来决定什么样的事件该如何处理
        这是最能体现Channel模块作用的功能之一
    */
    // 事件处理, 一旦连接触发了事件,就调用这个函数,自己触发了什么事件如何处理
    void HandleEvent()
    {
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            /*不管任何事件，都调用的回调函数*/
            if (_read_callback)
                _read_callback();
        }
        /*有可能会释放连接的操作事件，一次只处理一个*/
        if (_revents & EPOLLOUT)
        {
            if (_write_callback)
                _write_callback();
        }
        else if (_revents & EPOLLERR)
        {
            if (_error_callback)
                _error_callback();
        }
        else if (_revents & EPOLLHUP)
        {
            if (_close_callback)
                _close_callback();
        }
        /*不管任何事件，都调用的回调函数*/
        if (_event_callback)
            _event_callback();
    }
};

#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _epfd;                                // epoll模型fd
    struct epoll_event _evs[MAX_EPOLLEVENTS]; // 通过epoll_wait()返回的就绪事件数组(里面有对应的fd)
    std::unordered_map<int, Channel *> _channels;

private:
    // 对epoll的直接操作
    void Update(Channel *channel, int op)
    {
        /*
            int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev);
            epfd：指定的epoll模型。
            op：表示具体的动作，用三个宏来表示。
            fd：需要监视的文件描述符。
            event：需要监视该文件描述符上的哪些事件。
            op有三种取值:
            EPOLL_CTL_ADD：注册新的文件描述符到指定的epoll模型中。
            EPOLL_CTL_MOD：修改已经注册的文件描述符的监听事件。
            EPOLL_CTL_DEL：从epoll模型中删除指定的文件描述符。
        */
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
        {
            ELOG("EPOLLCTL FAILED!");
        }
        return;
    }
    // 判断一个Channel是否已经添加了事件监控
    bool HasChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
        {
            return false;
        }
        return true;
    }

public:
    Poller()
    {
        // int epoll_create(int size);
        // size参数是被忽略的，但size的值必须设置为大于0的值。
        _epfd = epoll_create(MAX_EPOLLEVENTS);
    }
    // 添加或者修改监控事件
    void UpdateEvent(Channel *channel)
    {
        bool ret = HasChannel(channel);
        if (ret == false)
        {
            // 不存在则添加(外部添加)
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        // 到这里,就是修改操作(epoll内部添加)
        return Update(channel, EPOLL_CTL_MOD);
    }
    // 移除监控事件
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
        {
            _channels.erase(it); // 外部删除
        }
        Update(channel, EPOLL_CTL_DEL); // epoll内部删除
    }
    // 开始监控,返回活连接
    void Poll(std::vector<Channel *> *active)
    {
        /*
            int epoll_wait(int epfd, struct epoll_event *evs, int maxevents, int timeout);
             epfd：指定的epoll模型。
             events：内核会将已经就绪的事件拷贝到events数组当中（events不能是空指针，内核只负责将就绪事件拷贝到该数组中，不会帮我们在用户态中分配内存）。
             maxevents：events数组中的元素个数，该值不能大于创建epoll模型时传入的size值。
             timeout：表示epoll_wait函数的超时时间，单位是毫秒（ms）
            timeout:取值三种
                -1：epoll_wait调用后进行阻塞等待;
                0：epoll_wait调用后进行非阻塞等待;
                特定的时间值;
            返回值:
                如果函数调用成功，则返回有事件就绪的文件描述符个数。
                如果timeout时间耗尽，则返回0。
                如果函数调用失败，则返回-1，同时错误码会被设置
        */
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
        if (nfds < 0)
        {
            // 阻塞期间,被信号打断
            if (errno == EINTR)
            {
                return;
            }
            ELOG("RPOLL WAIT ERROE: %s\n", strerror(errno));
            abort(); // 退出程序
        }
        for (int i = 0; i < nfds; i++)
        {
            // _evs  :通过epoll_wait()返回的就绪事件数组(里面有对应的fd), 通过fd找到对应的channel,
            // 把从内核返回来的就绪事件,设置到channel的revent中,最后将所有的channel通过active数组打包带出
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetREvent(_evs[i].events); // 设置实际的就绪事件
            active->push_back(it->second);
        }
    }
};

//因为EventLoop还没有实现，为了测试Channel和Poller，先暂时直接用Poller里的接口进行操作
void Channel::Remove() { return _poller->RemoveEvent(this); }
void Channel::Update() { return _poller->UpdateEvent(this); }
